import React from 'react';

/**
 * 根据给定的字段过滤数据，并返回每个唯一值的计数的对象数组。
 *
 * @param {Array} data - 输入数据。
 * @param {string} field - 过滤数据的字段。
 * @param isArray
 * @returns {Array} - 包含每个唯一值的计数的对象数组。
 */
export function filterDataPlus(data, field, isArray = false) {
  // 如果 data 未定义，则返回一个空数组
  if (data === undefined) return [];

  // 根据数据的每一行的字段创建一个单词数组
  let words = data.flatMap((row) => {
    if (Object.prototype.hasOwnProperty.call(row, field)) {
      return row[field] === '' ? ' ' : row[field];
    }
    return 'field不存在';
  });
  if (isArray) {
    words = data.flatMap((row) => {
      if (Object.prototype.hasOwnProperty.call(row, field)) {
        const fieldValue = row[field];
        if (fieldValue === '') {
          return ' ';
        }
        if (fieldValue) {
          return fieldValue.split(',');
        }
        return [];
      }
      return 'field不存在';
    });
  }

  // 创建一个 Map 来存储每个单词的计数
  const countMap = new Map();
  words.forEach((word) => {
    // 检查该单词是否已存在于 Map 中
    if (countMap.has(word)) {
      // 如果存在，则数量加1
      countMap.set(word, countMap.get(word) + 1);
    } else {
      // 如果不存在，则初始化数量为1
      countMap.set(word, 1);
    }
  });

  // 将 Map 转为对象数组，并根据计数降序排序
  const kvs = Array.from(countMap, ([key, value]) => ({ key, value }))
    .sort((a, b) => b.value - a.value);

  // 创建一个新的对象数组，包含 text 和 value 属性
  return kvs.filter((kv) => kv.key !== null)
    .map((kv) => ({
      text: `${kv.key} (${kv.value})`,
      value: kv.key,
    }));
}

export function filterDataPlusByMap(data, map, field) {
  // 如果 data 未定义，则返回一个空数组
  if (data === undefined || map === undefined) return [];

  // 根据数据的每一行的字段创建一个单词数组
  const words = data
    .map((row) => row[field] ?? 'field不存在')
    // .map((row) => (Object.prototype.hasOwnProperty.call(row, field) ? row[field] : 'field不存在'))
    .filter((item) => item !== null);

  // 创建一个 Map 来存储每个单词的计数
  const countMap = new Map();
  words.forEach((word) => {
    // 检查该单词是否已存在于 Map 中
    if (countMap.has(word)) {
      // 如果存在，则数量加1
      countMap.set(word, countMap.get(word) + 1);
    } else {
      // 如果不存在，则初始化数量为1
      countMap.set(word, 1);
    }
  });

  // 将 Map 转为对象数组，并根据计数降序排序
  const kvs = Array.from(countMap, ([key, value]) => ({ key, value }))
    .sort((a, b) => b.value - a.value);

  // 创建一个新的对象数组，包含 text 和 value 属性
  return kvs.map((kv) => (
    {
      text: (
        <>
          {map.has(kv.key) ? map.get(kv.key) : kv.key}
          <>{` (${kv.value})`}</>
        </>
      ),
      value: kv.key,
    }));
}

export function filterColumnValue(value, record, field) {
  return (
    Object.prototype.hasOwnProperty.call(record, field)
    && ((record[field] !== null && record[field] === value) || (record[field] === '' && value === ' '))
  );
}

export function filterColumnArrayValue(value, record, field) {
  if (Object.prototype.hasOwnProperty.call(record, field)) {
    if (record[field] !== null) {
      if (record[field].indexOf(',') !== -1) {
        return record[field].split(',').map((item) => item === value).includes(true);
      }
      return record[field] === value;
    }
    return record[field] === '' && value === ' ';
  }
  return false;
}
